పాండాస్ మెమరీ వినియోగాన్ని ఆప్టిమైజ్ చేయడానికి సమగ్ర గైడ్, ఇందులో డేటా రకాలు, చంకింగ్, వర్గీకరణ వేరియబుల్స్ మరియు పెద్ద డేటాసెట్‌లను నిర్వహించడానికి సమర్థవంతమైన పద్ధతులు ఉన్నాయి.
పాండాస్ పనితీరు ఆప్టిమైజేషన్: మెమరీ వినియోగాన్ని తగ్గించడంలో నైపుణ్యం
పాండాస్ అనేది డేటా విశ్లేషణ కోసం ఒక శక్తివంతమైన పైథాన్ లైబ్రరీ, ఇది అనుకూలమైన డేటా స్ట్రక్చర్‌లు మరియు డేటా విశ్లేషణ సాధనాలను అందిస్తుంది. అయితే, పెద్ద డేటాసెట్‌లతో పనిచేసేటప్పుడు, మెమరీ వినియోగం ఒక ముఖ్యమైన అడ్డంకిగా మారవచ్చు, ఇది పనితీరును ప్రభావితం చేస్తుంది మరియు మీ ప్రోగ్రామ్‌లు క్రాష్ అయ్యేలా చేస్తుంది. ఈ సమగ్ర గైడ్ పాండాస్ మెమరీ వినియోగాన్ని ఆప్టిమైజ్ చేయడానికి వివిధ పద్ధతులను అన్వేషిస్తుంది, పెద్ద డేటాసెట్‌లను మరింత సమర్ధవంతంగా మరియు సమర్థవంతంగా నిర్వహించడానికి మిమ్మల్ని అనుమతిస్తుంది.
పాండాస్ మెమరీ వినియోగాన్ని అర్థం చేసుకోవడం
ఆప్టిమైజేషన్ పద్ధతులలోకి వెళ్ళే ముందు, పాండాస్ డేటాను మెమరీలో ఎలా నిల్వ చేస్తుందో అర్థం చేసుకోవడం చాలా ముఖ్యం. పాండాస్ ప్రధానంగా డేటాఫ్రేమ్‌లు మరియు సిరీస్‌లలో డేటాను నిల్వ చేయడానికి NumPy శ్రేణులను ఉపయోగిస్తుంది. ప్రతి కాలమ్ యొక్క డేటా రకం మెమరీ ఫుట్‌ప్రింట్‌ను గణనీయంగా ప్రభావితం చేస్తుంది. ఉదాహరణకు, ఒక int64 కాలమ్ ఒక int32 కాలమ్ కంటే రెట్టింపు మెమరీని వినియోగిస్తుంది.
మీరు .memory_usage() పద్ధతిని ఉపయోగించి డేటాఫ్రేమ్ యొక్క మెమరీ వినియోగాన్ని తనిఖీ చేయవచ్చు:
import pandas as pd
data = {
'col1': [1, 2, 3, 4, 5],
'col2': ['A', 'B', 'C', 'D', 'E'],
'col3': [1.1, 2.2, 3.3, 4.4, 5.5]
}
df = pd.DataFrame(data)
memory_usage = df.memory_usage(deep=True)
print(memory_usage)
వస్తువు (స్ట్రింగ్) కాలమ్‌ల మెమరీ వినియోగాన్ని ఖచ్చితంగా లెక్కించడానికి deep=True ఆర్గ్యుమెంట్ అవసరం.
మెమరీ వినియోగాన్ని తగ్గించడానికి పద్ధతులు
1. సరైన డేటా రకాలను ఎంచుకోవడం
ప్రతి కాలమ్‌కు తగిన డేటా రకాన్ని ఎంచుకోవడం మెమరీ వినియోగాన్ని తగ్గించడంలో అత్యంత ప్రాథమిక దశ. పాండాస్ స్వయంచాలకంగా డేటా రకాలను ఊహిస్తుంది, కానీ అది తరచుగా అవసరమైన దానికంటే ఎక్కువ మెమరీ-ఇంటెన్సివ్ రకాలకు డిఫాల్ట్ అవుతుంది. ఉదాహరణకు, 0 మరియు 100 మధ్య పూర్ణాంకాలను కలిగి ఉన్న కాలమ్‌కు int64 రకం కేటాయించబడవచ్చు, అయినప్పటికీ int8 లేదా uint8 సరిపోతుంది.
ఉదాహరణ: సంఖ్యా రకాలను డౌన్‌కాస్ట్ చేయడం
మీరు downcast పరామితితో pd.to_numeric() ఫంక్షన్‌ను ఉపయోగించి సంఖ్యా రకాలను చిన్న ప్రాతినిధ్యాలకు డౌన్‌కాస్ట్ చేయవచ్చు:
def reduce_mem_usage(df):
"""Iterate through all the columns of a dataframe and modify the data type
to reduce memory usage.
"""
start_mem = df.memory_usage().sum() / 1024**2
print('Memory usage of dataframe is {:.2f} MB'.format(start_mem))
for col in df.columns:
if df[col].dtype == 'object':
continue # Skip strings, handle them separately
col_type = df[col].dtype
if col_type in ['int64','int32','int16']:
c_min = df[col].min()
c_max = df[col].max()
if c_min > np.iinfo(np.int8).min and c_max < np.iinfo(np.int8).max:
df[col] = df[col].astype(np.int8)
elif c_min > np.iinfo(np.int16).min and c_max < np.iinfo(np.int16).max:
df[col] = df[col].astype(np.int16)
elif c_min > np.iinfo(np.int32).min and c_max < np.iinfo(np.int32).max:
df[col] = df[col].astype(np.int32)
else:
df[col] = df[col].astype(np.int64)
elif col_type in ['float64','float32']:
c_min = df[col].min()
c_max = df[col].max()
if c_min > np.finfo(np.float16).min and c_max < np.finfo(np.float16).max:
df[col] = df[col].astype(np.float16)
elif c_min > np.finfo(np.float32).min and c_max < np.finfo(np.float32).max:
df[col] = df[col].astype(np.float32)
else:
df[col] = df[col].astype(np.float64)
end_mem = df.memory_usage().sum() / 1024**2
print('Memory usage after optimization is: {:.2f} MB'.format(end_mem))
print('Decreased by {:.1f}%'.format(100 * (start_mem - end_mem) / start_mem))
return df
ఉదాహరణ: స్ట్రింగ్‌లను వర్గీకరణ రకాలుగా మార్చడం
ఒక కాలమ్‌లో పరిమిత సంఖ్యలో ప్రత్యేక స్ట్రింగ్ విలువలు ఉంటే, దానిని వర్గీకరణ రకంగా మార్చడం మెమరీ వినియోగాన్ని గణనీయంగా తగ్గిస్తుంది. వర్గీకరణ రకాలు ప్రత్యేక విలువలను ఒక్కసారి మాత్రమే నిల్వ చేస్తాయి మరియు కాలమ్‌లోని ప్రతి మూలకాన్ని ప్రత్యేక విలువలను సూచించే పూర్ణాంక కోడ్‌గా సూచిస్తాయి.
df['col2'] = df['col2'].astype('category')
గ్లోబల్ ఈ-కామర్స్ ప్లాట్‌ఫారమ్ కోసం కస్టమర్ లావాదేవీల డేటాసెట్‌ను పరిగణించండి. 'Country' కాలమ్‌లో కేవలం కొన్ని వందల ప్రత్యేక దేశాల పేర్లు ఉండవచ్చు, అయితే డేటాసెట్‌లో మిలియన్ల కొద్దీ లావాదేవీలు ఉంటాయి. 'Country' కాలమ్‌ను వర్గీకరణ రకంగా మార్చడం వలన మెమరీ వినియోగం గణనీయంగా తగ్గుతుంది.
2. చంకింగ్ మరియు ఇటరేషన్
మెమరీలో సరిపోని అత్యంత పెద్ద డేటాసెట్‌లతో వ్యవహరించేటప్పుడు, మీరు pd.read_csv() లేదా pd.read_excel() లోని chunksize పరామితిని ఉపయోగించి డేటాను చంక్‌లలో ప్రాసెస్ చేయవచ్చు. ఇది డేటాను చిన్న, నిర్వహించదగిన ముక్కలుగా లోడ్ చేయడానికి మరియు ప్రాసెస్ చేయడానికి మిమ్మల్ని అనుమతిస్తుంది.
for chunk in pd.read_csv('large_dataset.csv', chunksize=100000):
# Process the chunk (e.g., perform calculations, filtering, aggregation)
print(f"Processing chunk with {len(chunk)} rows")
# Optionally, append results to a file or database.
ఉదాహరణ: పెద్ద లాగ్ ఫైల్‌లను ప్రాసెస్ చేయడం
గ్లోబల్ నెట్‌వర్క్ ఇన్‌ఫ్రాస్ట్రక్చర్ నుండి భారీ లాగ్ ఫైల్‌ను ప్రాసెస్ చేయడాన్ని ఊహించండి. లాగ్ ఫైల్ మెమరీలో సరిపోనంత పెద్దది. చంకింగ్‌ను ఉపయోగించడం ద్వారా, మీరు లాగ్ ఫైల్ ద్వారా పునరావృతం చేయవచ్చు, నిర్దిష్ట ఈవెంట్‌లు లేదా నమూనాల కోసం ప్రతి చంక్‌ను విశ్లేషించవచ్చు మరియు మెమరీ పరిమితులను మించకుండా ఫలితాలను సమగ్రపరచవచ్చు.
3. అవసరమైన కాలమ్‌లను మాత్రమే ఎంచుకోవడం
తరచుగా, డేటాసెట్‌లలో మీ విశ్లేషణకు సంబంధించినవి కాని కాలమ్‌లు ఉంటాయి. అవసరమైన కాలమ్‌లను మాత్రమే లోడ్ చేయడం వలన మెమరీ వినియోగం గణనీయంగా తగ్గుతుంది. మీరు pd.read_csv() లోని usecols పరామితిని ఉపయోగించి కావలసిన కాలమ్‌లను పేర్కొనవచ్చు.
df = pd.read_csv('large_dataset.csv', usecols=['col1', 'col2', 'col3'])
ఉదాహరణ: అమ్మకాల డేటాను విశ్లేషించడం
టాప్-పెర్ఫార్మింగ్ ఉత్పత్తులను గుర్తించడానికి మీరు అమ్మకాల డేటాను విశ్లేషిస్తున్నట్లయితే, మీకు 'Product ID', 'Sales Quantity' మరియు 'Sales Revenue' కాలమ్‌లు మాత్రమే అవసరం కావచ్చు. ఈ కాలమ్‌లను మాత్రమే లోడ్ చేయడం వలన మొత్తం డేటాసెట్‌ను లోడ్ చేయడంతో పోలిస్తే మెమరీ వినియోగం తగ్గుతుంది, ఇందులో కస్టమర్ జనాభా, షిప్పింగ్ చిరునామాలు మరియు ఇతర అసంబద్ధమైన సమాచారం ఉండవచ్చు.
4. స్పార్స్ డేటా స్ట్రక్చర్‌లను ఉపయోగించడం
మీ డేటాఫ్రేమ్‌లో చాలా మిస్సింగ్ విలువలు (NaNలు) లేదా సున్నాలు ఉంటే, డేటాను మరింత సమర్ధవంతంగా సూచించడానికి మీరు స్పార్స్ డేటా స్ట్రక్చర్‌లను ఉపయోగించవచ్చు. స్పార్స్ డేటాఫ్రేమ్‌లు మిస్సింగ్ కాని లేదా సున్నా కాని విలువలను మాత్రమే నిల్వ చేస్తాయి, స్పార్స్ డేటాతో వ్యవహరించేటప్పుడు మెమరీ వినియోగాన్ని గణనీయంగా తగ్గిస్తాయి.
sparse_series = df['col1'].astype('Sparse[float]')
sparse_df = sparse_series.to_frame()
ఉదాహరణ: కస్టమర్ రేటింగ్‌లను విశ్లేషించడం
పెద్ద సంఖ్యలో ఉత్పత్తుల కోసం కస్టమర్ రేటింగ్‌ల డేటాసెట్‌ను పరిగణించండి. చాలా మంది కస్టమర్‌లు ఉత్పత్తులలో చిన్న ఉపసమితిని మాత్రమే రేట్ చేస్తారు, ఫలితంగా రేటింగ్‌ల స్పార్స్ మ్యాట్రిక్స్ ఏర్పడుతుంది. ఈ డేటాను నిల్వ చేయడానికి స్పార్స్ డేటాఫ్రేమ్‌ను ఉపయోగించడం వలన దట్టమైన డేటాఫ్రేమ్‌తో పోలిస్తే మెమరీ వినియోగం గణనీయంగా తగ్గుతుంది.
5. డేటాను కాపీ చేయకుండా ఉండటం
పాండాస్ కార్యకలాపాలు కొన్నిసార్లు డేటాఫ్రేమ్‌ల కాపీలను సృష్టించగలవు, ఇది మెమరీ వినియోగాన్ని పెంచుతుంది. ఒక డేటాఫ్రేమ్‌ను అక్కడికక్కడే సవరించడం (సాధ్యమైనప్పుడు) అనవసరమైన కాపీ చేయడాన్ని నివారించడంలో సహాయపడుతుంది.
ఉదాహరణకు, దీనికి బదులుగా:
df = df[df['col1'] > 10]
దీనిని ఉపయోగించడాన్ని పరిగణించండి:
df.drop(df[df['col1'] <= 10].index, inplace=True)
inplace=True ఆర్గ్యుమెంట్ కాపీని సృష్టించకుండా డేటాఫ్రేమ్‌ను నేరుగా సవరిస్తుంది.
6. స్ట్రింగ్ నిల్వను ఆప్టిమైజ్ చేయడం
స్ట్రింగ్ కాలమ్‌లు గణనీయమైన మెమరీని వినియోగించుకోగలవు, ముఖ్యంగా అవి పొడవైన స్ట్రింగ్‌లను లేదా అనేక ప్రత్యేక విలువలను కలిగి ఉంటే. ఇంతకు ముందు చెప్పినట్లుగా, స్ట్రింగ్‌లను వర్గీకరణ రకాలుగా మార్చడం ఒక సమర్థవంతమైన పద్ధతి. మరొక విధానం, వీలైతే చిన్న స్ట్రింగ్ ప్రాతినిధ్యాలను ఉపయోగించడం.
ఉదాహరణ: స్ట్రింగ్ పొడవును తగ్గించడం
ఒక కాలమ్‌లో స్ట్రింగ్‌లుగా నిల్వ చేయబడిన ఐడెంటిఫైయర్‌లు ఉండి, వాటిని పూర్ణాంకాలుగా సూచించగలిగితే, వాటిని పూర్ణాంకాలుగా మార్చడం మెమరీని ఆదా చేస్తుంది. ఉదాహరణకు, ప్రస్తుతం "PROD-1234" వంటి స్ట్రింగ్‌లుగా నిల్వ చేయబడిన ఉత్పత్తి IDలను పూర్ణాంక IDలకు మ్యాప్ చేయవచ్చు.
7. మెమరీ కంటే పెద్ద డేటాసెట్‌ల కోసం డాస్క్‌ని ఉపయోగించడం
చంకింగ్‌తో కూడా, మెమరీలో సరిపోనంత పెద్ద డేటాసెట్‌ల కోసం, డాస్క్‌ని ఉపయోగించడాన్ని పరిగణించండి. డాస్క్ అనేది పాండాస్ మరియు NumPy తో బాగా కలిసిపోయే సమాంతర కంప్యూటింగ్ లైబ్రరీ. ఇది డేటాసెట్‌లను చిన్న చంక్‌లుగా విడదీయడం ద్వారా మరియు వాటిని బహుళ కోర్‌లలో లేదా బహుళ మెషీన్‌లలో సమాంతరంగా ప్రాసెస్ చేయడం ద్వారా మెమరీ కంటే పెద్ద డేటాసెట్‌లతో పని చేయడానికి మిమ్మల్ని అనుమతిస్తుంది.
import dask.dataframe as dd
ddf = dd.read_csv('large_dataset.csv')
# Perform operations on the Dask DataFrame (e.g., filtering, aggregation)
result = ddf[ddf['col1'] > 10].groupby('col2').mean().compute()
compute() పద్ధతి వాస్తవ గణనను ప్రేరేపిస్తుంది మరియు ఫలితాలను కలిగి ఉన్న పాండాస్ డేటాఫ్రేమ్‌ను తిరిగి ఇస్తుంది.
ఉత్తమ పద్ధతులు మరియు పరిగణనలు
- మీ కోడ్‌ను ప్రొఫైల్ చేయండి: మెమరీ బాటిల్‌నెక్‌లను గుర్తించడానికి మరియు అత్యంత ప్రభావవంతమైన ప్రాంతాలపై మీ ఆప్టిమైజేషన్ ప్రయత్నాలను కేంద్రీకరించడానికి ప్రొఫైలింగ్ సాధనాలను ఉపయోగించండి.
- వివిధ పద్ధతులను పరీక్షించండి: సరైన మెమరీ తగ్గింపు పద్ధతి మీ డేటాసెట్ యొక్క నిర్దిష్ట లక్షణాలపై ఆధారపడి ఉంటుంది. మీ ఉపయోగ సందర్భం కోసం ఉత్తమ పరిష్కారాన్ని కనుగొనడానికి వివిధ విధానాలతో ప్రయోగం చేయండి.
- మెమరీ వినియోగాన్ని పర్యవేక్షించండి: మీ ఆప్టిమైజేషన్‌లు ప్రభావవంతంగా ఉన్నాయని నిర్ధారించుకోవడానికి మరియు మెమరీ లేని లోపాలను నివారించడానికి డేటా ప్రాసెసింగ్ సమయంలో మెమరీ వినియోగాన్ని ట్రాక్ చేయండి.
- మీ డేటాను అర్థం చేసుకోండి: మీ డేటాను లోతుగా అర్థం చేసుకోవడం అత్యంత తగిన డేటా రకాలు మరియు ఆప్టిమైజేషన్ పద్ధతులను ఎంచుకోవడానికి చాలా ముఖ్యం.
- ట్రేడ్-ఆఫ్‌లను పరిగణించండి: కొన్ని మెమరీ ఆప్టిమైజేషన్ పద్ధతులు స్వల్ప పనితీరు ఓవర్‌హెడ్‌ను పరిచయం చేయవచ్చు. తగ్గిన మెమరీ వినియోగం వల్ల కలిగే ప్రయోజనాలను ఏదైనా సంభావ్య పనితీరు ప్రభావంతో పోల్చి చూడండి.
- మీ ఆప్టిమైజేషన్‌లను డాక్యుమెంట్ చేయండి: మీ కోడ్ నిర్వహించదగినదిగా మరియు ఇతరులకు అర్థమయ్యేలా చూసుకోవడానికి మీరు అమలు చేసిన మెమరీ ఆప్టిమైజేషన్ పద్ధతులను స్పష్టంగా డాక్యుమెంట్ చేయండి.
ముగింపు
పాండాస్ మెమరీ వినియోగాన్ని ఆప్టిమైజ్ చేయడం పెద్ద డేటాసెట్‌లతో సమర్ధవంతంగా మరియు ప్రభావవంతంగా పనిచేయడానికి అవసరం. పాండాస్ డేటాను ఎలా నిల్వ చేస్తుందో అర్థం చేసుకోవడం, సరైన డేటా రకాలను ఎంచుకోవడం, చంకింగ్‌ను ఉపయోగించడం మరియు ఇతర ఆప్టిమైజేషన్ పద్ధతులను ఉపయోగించడం ద్వారా, మీరు మెమరీ వినియోగాన్ని గణనీయంగా తగ్గించవచ్చు మరియు మీ డేటా విశ్లేషణ వర్క్‌ఫ్లోల పనితీరును మెరుగుపరచవచ్చు. పాండాస్‌లో మెమరీ వినియోగాన్ని తగ్గించడంలో నైపుణ్యం సాధించడానికి కీలక పద్ధతులు మరియు ఉత్తమ పద్ధతుల యొక్క సమగ్ర అవలోకనాన్ని ఈ గైడ్ అందించింది. మీ నిర్దిష్ట ఉపయోగ సందర్భం కోసం ఉత్తమ ఫలితాలను సాధించడానికి మీ కోడ్‌ను ప్రొఫైల్ చేయండి, విభిన్న పద్ధతులను పరీక్షించండి మరియు మెమరీ వినియోగాన్ని పర్యవేక్షించండి. ఈ సూత్రాలను వర్తింపజేయడం ద్వారా, మీరు పాండాస్ యొక్క పూర్తి సామర్థ్యాన్ని అన్‌లాక్ చేయవచ్చు మరియు అత్యంత డిమాండింగ్ డేటా విశ్లేషణ సవాళ్లను కూడా పరిష్కరించవచ్చు.
ఈ పద్ధతులలో నైపుణ్యం సాధించడం ద్వారా, ప్రపంచవ్యాప్తంగా ఉన్న డేటా శాస్త్రవేత్తలు మరియు విశ్లేషకులు పెద్ద డేటాసెట్‌లను నిర్వహించగలరు, ప్రాసెసింగ్ వేగాన్ని మెరుగుపరచగలరు మరియు వారి డేటా నుండి లోతైన అంతర్దృష్టులను పొందగలరు. ఇది మరింత సమర్థవంతమైన పరిశోధన, మెరుగైన వ్యాపార నిర్ణయాలు మరియు చివరికి, మరింత డేటా-ఆధారిత ప్రపంచానికి దోహదపడుతుంది.